inline static size_t aligned_size(size_t alignment, size_t size)
  {
   ...
  }

  SNMALLOC_FAST_PATH static size_t aligned_size(size_t alignment, size_t size)
  {
    // Client responsible for checking alignment is not zero
    assert(alignment != 0);
    // Client responsible for checking alignment is not above SUPERSLAB_SIZE
    assert(alignment <= SUPERSLAB_SIZE);
    // Client responsible for checking alignment is a power of two
    assert(bits::next_pow2(alignment) == alignment);

    size = bits::max(size, alignment);
    snmalloc::sizeclass_t sc = size_to_sizeclass(size);
    if (sc >= NUM_SIZECLASSES)
    {
      // large allocs are 16M aligned, which is maximum we guarantee
      return 1;
    }
    size_t t = 2;
    for (; sc < NUM_SIZECLASSES; sc++, t++)
    {
      size = sizeclass_to_size(sc);
      if ((size & (~size + 1)) >= alignment)
      {
        return t;
      }
    }
    // Give max alignment.
    return t;
  }

#include <iostream>
#include "src/snmalloc.h"
#include <cstdlib>
#define LIMIT 10000000
int main() {
    size_t all = 0;
    size_t max = 0;
    srand(time(NULL));
    for(size_t i = 0; i < LIMIT; ++i) {
        size_t a = snmalloc::bits::next_pow2(1 + (size_t)rand() % (snmalloc::SUPERSLAB_SIZE));
        size_t m = rand();
        auto t = snmalloc::aligned_size(a, m);
        all += t;
        max = std::max(max, t);
    }
    std::cout << "ave: " << (double)all / (double)LIMIT << ", max: " << max << std::endl;
}

➜  cmake-build-debug git:(master) ✗ for i in $(seq 1 10); do ./test2; done
ave: 1.00572, max: 5
ave: 1.00572, max: 5
ave: 1.00572, max: 5
ave: 1.00569, max: 5
ave: 1.00569, max: 5
ave: 1.00569, max: 5
ave: 1.00572, max: 5
ave: 1.00572, max: 5
ave: 1.00572, max: 5
ave: 1.00572, max: 5

auto t = snmalloc::aligned_size(a, m);

auto t = snmalloc::aligned_size(a, m) - std::max(a,m);

size_t m = rand() % snmalloc::size_to_sizeclass(snmalloc::NUM_SIZECLASSES);

SNMALLOC_FAST_PATH static size_t aligned_size(size_t alignment, size_t size)
{
    // Client responsible for checking alignment is not zero
    assert(alignment != 0);
    // Client responsible for checking alignment is not above SUPERSLAB_SIZE
    assert(alignment <= SUPERSLAB_SIZE);
    // Client responsible for checking alignment is a power of two
    assert(bits::next_pow2(alignment) == alignment);

    return ((alignment - 1) | (size - 1)) + 1;
}

#include <iostream>
#include <random>
#include <snmalloc.h>
#include <test/setup.h>
NOINLINE
snmalloc::sizeclass_t size_to_sizeclass(size_t size)
{
  return snmalloc::size_to_sizeclass(size);
}

NOINLINE
size_t sizeclass_to_size(snmalloc::sizeclass_t sc)
{
  return snmalloc::sizeclass_to_size(sc);
}

NOINLINE
size_t aligned_size(size_t alignment, size_t size)
{
  return snmalloc::aligned_size(alignment, size);
}

int main(int, char**)
{
  setup();

  bool failed = false;

  std::random_device dev;
  unsigned int seed = dev();
  std::cout << "random seed: " << seed << std::endl;

  std::uniform_int_distribution<size_t> dist(1);
  std::mt19937 rng(seed);

  for (snmalloc::sizeclass_t sz = 0; sz < snmalloc::NUM_SIZECLASSES; sz++)
  {
    // Separate printing for small and medium sizeclasses
    if (sz == snmalloc::NUM_SMALL_CLASSES)
      std::cout << std::endl;

    size_t this_size = snmalloc::sizeclass_to_size(sz),
           pre_size = (sz != 0) ? snmalloc::sizeclass_to_size(sz - 1) : 1;

    for (size_t alignment = snmalloc::bits::next_pow2(pre_size);
         alignment < this_size;
         alignment = snmalloc::bits::next_pow2(alignment + 1))
    {
      std::cout << std::endl;
      std::cout << "-- alignment: " << alignment << std::endl;
      for (int i = 0; i < 100; ++i)
      {
        size_t size = dist(rng) % alignment;
        std::cout << "---- size: " << size;
        bool flag = sizeclass_to_size(size_to_sizeclass(aligned_size(alignment, size))) %
            alignment !=
            0;
        std::cout << ((flag) ? " [FAILED]" : " [SUCCESS]") << std::endl;
        failed |= flag;
      }
    }
  }

  if (failed)
    abort();
}

void test_align_size()
{
  bool failed = false;

  assert(aligned_size(128, 160) == 256);

  for (size_t size = 1; size < sizeclass_to_size(NUM_SIZECLASSES - 1); size++)
  {
    size_t rsize = sizeclass_to_size(size_to_sizeclass(size));

    if (rsize < size)
    {
      std::cout << "Size class rounding shrunk: " << size << " -> " << rsize
                << std::endl;
      failed |= true;
    }

    auto lsb_rsize = rsize & -rsize;
    auto lsb_size = size & -size;
    if (lsb_rsize < lsb_size)
    {
      std::cout << "Original size more aligned than rounded size: " << size
                << " (" << lsb_size << ") -> " << rsize << " (" << lsb_rsize
                << ")" << std::endl;
      failed |= true;
    }

    for (size_t alignment_bits = 0; alignment_bits < SUPERSLAB_BITS;
         alignment_bits++)
    {
      auto alignment = (size_t)1 << alignment_bits;
      auto asize = aligned_size(alignment, size);

      if (asize < size)
      {
        std::cout << "Shrunk! Alignment: " << alignment << " Size: " << size
                  << " ASize: " << asize << std::endl;
        failed |= true;
      }

      if ((asize & (alignment - 1)) != 0)
      {
        std::cout << "Not aligned! Alignment: " << alignment
                  << " Size: " << size << " ASize: " << asize << std::endl;
        failed |= true;
      }
    }
  }

  if (failed)
    abort();
}